"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * 接口一方面可以在面向对象变成中表示行为的抽象  另一方面可以描述对象的形状
 * 接口就是把一些类中共有的属性和方法抽象出来，可以用来约束实现此接口的类
 * 一个类可以继承另一个类并实现多个接口
 * 接口像插件一样是用来增强类的，而抽象类是具体类的抽象概念
 * 一个类可以实现多个接口，一个接口也可以被多个类实现，但一个类可以有多个子类 但只能有一个父类
 */
var a;
(function (a) {
    var speakMan = {
        name: 'smd',
        speak: function () {
        }
    };
    var Person = /** @class */ (function () {
        function Person() {
        }
        Person.prototype.speak = function () {
        };
        Person.prototype.eat = function () {
        };
        return Person;
    }());
})(a || (a = {}));
var p = {
    id: 0,
    name: "smd",
    age: 18
};
var ChineseMan = /** @class */ (function () {
    function ChineseMan() {
    }
    ChineseMan.prototype.speakChinese = function () {
    };
    ChineseMan.prototype.speak = function () {
    };
    return ChineseMan;
}());
var p3 = {
    id: 1
};
var discount = function (price) {
    return 0.9 * price;
};
discount(100);
var user = {
    1: '1'
};
var arr = ['1'];
// 描述构造函数类型的接口
var Animal = /** @class */ (function () {
    function Animal(name) {
        this.name = name;
    }
    return Animal;
}());
function createClass(clazz, name) {
    return new clazz(name);
}
var anm = createClass(Animal, 'cat');
console.log(anm.name); // cat
/**
 * interface 中 描述函数的new关键字必须添加
 * 当创建一个类的时候  会得到两个类型
 * 1.构造函数的函数类型
 * 2.类的实例类型
 */
(function (a) {
    var Component = /** @class */ (function () {
        function Component() {
            this.myName = '实例名称属性';
        }
        Component.myName = '静态名称属性';
        return Component;
    }());
    // Component类名本身表示实例的类型
    var c = new Component();
    var f = Component; // 等号后边的 Component在此处是值
})(a || (a = {}));
var b;
(function (b) {
    function Component() {
        this.myName = '实例名称属性';
    }
    Component.myName = '静态名称属性';
})(b || (b = {}));
/**
 * 综上 如果interface 中没有new  则描述的是一个函数
 */
var c;
(function (c) {
    var Animal = /** @class */ (function () {
        function Animal(name) {
            this.name = name;
        }
        return Animal;
    }());
    var wc = function (name) { };
    // function createClass(clazz: withNameClass, name: string) {
    //   return new clazz(name)
    // }
    // let anm = createClass(Animal, 'cat')
    // console.log(anm.name) // cat
})(c || (c = {}));
/**
 * 但是如果加上new 则就是类的构造函数
 */
(function (c) {
    var Animal = /** @class */ (function () {
        function Animal(name) {
            this.name = name;
        }
        return Animal;
    }());
    var wc = Animal;
    // function createClass(clazz: withNameClass, name: string) {
    //   return new clazz(name)
    // }
    // let anm = createClass(Animal, 'cat')
    // console.log(anm.name) // cat
})(c || (c = {}));
var t1 = function (name) { };
var t2 = {
    a: t1
};
var t3 = function (name) { };
t3.age = 12;
var t4 = t3;
